home *** CD-ROM | disk | FTP | other *** search
/ Black Crawling Systems Archive Release 1.0 / Black Crawling Systems Archive Release 1.0 (L0pht Heavy Industries, Inc.)(1997).ISO / advisories / LC15SRC.ZIP / llist.c < prev    next >
C/C++ Source or Header  |  1997-07-01  |  8KB  |  338 lines
  1. /* routines for the linked list of struct user_struct's */
  2.  
  3. #include "includes.h"
  4.  
  5.  
  6. void add_list_struct(int, struct user_struct *current, char *str);
  7. void free_struct_list(struct user_struct *index);
  8. struct user_struct * init_linked_list();
  9. extern void fill_user_struct(int, char *, struct user_struct *);
  10. struct user_struct * remove_from_list(struct user_struct *record);
  11. struct user_struct * rewind_list(struct user_struct *record);
  12. void print_and_prune(struct user_struct *record, FILE *outlist);
  13. extern void printuser(struct user_struct *, FILE *);
  14. void build_linked_list(int, struct user_struct *, FILE *);
  15. extern int isvalid_userline(int, char *);
  16. struct user_struct * filter_disabled(struct user_struct *head, FILE *outlist);
  17. struct user_struct * setup_linked_list(int, FILE *pwlist, FILE *outlist);
  18. void nt_ify_list(struct user_struct *head);
  19. void print_hits(struct user_struct *head, FILE *outlist);
  20. struct user_struct * prune_list(struct user_struct *head);
  21. void swap_structs(struct user_struct *, struct user_struct *);
  22. extern int crackntdialect(struct user_struct *Ustruct, char *passwd, int check_case);
  23.  
  24.  
  25. void add_list_struct(int pwdump, struct user_struct *current, char *str){
  26.     struct user_struct *ptr, *newrecord;
  27.     
  28.     ptr = current;
  29.  
  30.     /* if this is the first then the username
  31.        will not be filled in yet. */
  32.     if (strlen(ptr->username) == 0){
  33.         fill_user_struct(pwdump, str, ptr);
  34.         return;
  35.     }
  36.  
  37.   /* put the list in order based upon the value of the LANMAN hash -
  38.      that way, when we are walking the list looking for comparisons
  39.      we can stop as soon as the value is greater than what we have
  40.      so we don't keep walking. */
  41.  
  42.     while (ptr->next != NULL)
  43.         ptr = ptr->next;
  44.     
  45.     newrecord = (struct user_struct *)malloc(sizeof(struct user_struct));
  46.     if (newrecord == NULL){
  47.         fprintf(stderr, "out of memory...add_user_struct newrecord\n");
  48.         exit(1);
  49.     }
  50.     fill_user_struct(pwdump, str, newrecord);
  51.     ptr->next = newrecord;
  52.     newrecord->previous = ptr;
  53.     newrecord->next = NULL;
  54. }
  55.  
  56. /* I don't know why the hell I walk through the damn thing and then go
  57.    backwards. Sigh, since it's only called once in the main prog it
  58.    isn't a significant performance hit */
  59. void free_struct_list(struct user_struct *index){
  60.  
  61.     /* go to the end of the list */
  62.     while (index->next != NULL)
  63.         index = index->next;
  64.  
  65.     /* if the end of the list is the beginning of the list
  66.        free it and return */
  67.     if (index->previous == NULL){
  68.         free(index);
  69.         return;
  70.     }
  71.  
  72.     /* work backwards free()ing as we go */
  73.     while (index->previous != NULL){
  74.         index = index->previous;
  75.         free(index->next);
  76.         index->next == NULL;
  77.     }
  78.     /* we are at the beginning - free it */
  79.     free(index);
  80. }
  81.  
  82. struct user_struct * init_linked_list(){
  83.     struct user_struct *newstruct;
  84.  
  85.     newstruct = (struct user_struct *)malloc(sizeof(struct user_struct));
  86.     if (newstruct == NULL){
  87.         fprintf(stderr, "out of memory...init_linked_list newstruct\n");
  88.         exit(1);
  89.     }
  90.     memset(newstruct, '\0', sizeof(struct user_struct));
  91.     return(newstruct);
  92. }
  93.  
  94. /* removes a node from the list and returns the head of the list */
  95. struct user_struct * remove_from_list(struct user_struct *record){
  96.     struct user_struct *tmp, *tmp2;
  97.  
  98.     if (record == NULL)
  99.         return(NULL);
  100.  
  101.     /* first record is only record in list */
  102.     if ((record->next == NULL) && (record->previous == NULL)){
  103.         free(record);
  104.         return(NULL);
  105.     }
  106.  
  107.     /* last record */
  108.     if (record->next == NULL){
  109.         tmp = record->previous;
  110.         free(record);
  111.         tmp->next = NULL;
  112.         while (tmp->previous != NULL)
  113.             tmp = tmp->previous;
  114.         return(tmp);
  115.     }
  116.     
  117.     /* first record */
  118.     if (record->previous == NULL){
  119.         tmp = record->next;
  120.         tmp->previous = NULL;
  121.         free(record);
  122.         return(tmp);
  123.     }
  124.  
  125.     /* middle record */
  126.     tmp = record->previous;
  127.     tmp2 = record->next;
  128.     tmp->next = tmp2;
  129.     tmp2->previous = tmp;
  130.     free(record);
  131.     return(tmp);
  132. }
  133.  
  134. struct user_struct * rewind_list(struct user_struct *record){
  135.  
  136.     struct user_struct *hold;
  137.  
  138.     hold = record;
  139.  
  140.     /* accident grabber */
  141.     if (record == NULL)
  142.         return(NULL);
  143.  
  144.     /* it's the first node being handed in */
  145.     if (record->previous == NULL)
  146.         return(record);
  147.  
  148.     /* it's not the first node */
  149.     while (record->previous != NULL) {
  150.         record = record->previous;
  151.     }
  152.     return(record);
  153. }
  154.  
  155. void build_linked_list(int pwdump, struct user_struct *head, FILE *pwlist){
  156.  
  157.     char user_entry[MAX_STRING];
  158.  
  159.     while (fgets(user_entry, MAX_STRING, pwlist) != NULL) {
  160.         if (isvalid_userline(pwdump, user_entry) == 0){
  161.             fprintf(stderr, "Invalid format: %s\n", user_entry);
  162.             continue;
  163.         }
  164.         add_list_struct(pwdump, head, user_entry);
  165.     }
  166. }
  167.  
  168. struct user_struct * filter_disabled(struct user_struct *head, FILE *outlist){
  169.     /* weed out the disabled accounts */
  170.     struct user_struct *index, *foo;
  171.  
  172.     index = foo = head;
  173.     
  174.     if (head == NULL)
  175.         return(head);
  176.  
  177.     while (foo != NULL){
  178.         if (strncmp(index->lmhash, "DISABLED?", 9) == 0){
  179.             fprintf(outlist, "User [%s] account is disabled\n",
  180.                 index->username);
  181.                 fflush(outlist);
  182.                 index = remove_from_list(index);
  183.                 if (index == NULL)
  184.                     foo = NULL;
  185.         } else {
  186.             if (index->next == NULL){
  187.                 foo = NULL;
  188.             } else {
  189.                 index = index->next;
  190.             }
  191.         }
  192.     }
  193.     return(rewind_list(index));
  194. }
  195.  
  196. struct user_struct *filter_nopasswd(struct user_struct *head, FILE *outlist){
  197.     /* weed out the accounts without passwords */
  198.     struct user_struct *index, *foo;
  199.  
  200.     if (head == NULL)
  201.         return(head);
  202.  
  203.     index = foo = head;
  204.     while (foo != NULL){
  205.         if (strncmp(index->lmhash, "NULL PASSWD?", 12) == 0){
  206.             fprintf(outlist, "User [%s] has a NULL PASSWD\n",
  207.                 index->username);
  208.                 fflush(outlist);
  209.                 index = remove_from_list(index);
  210.                 if (index == NULL)
  211.                     foo = NULL;
  212.         } else {
  213.             if (index->next == NULL){
  214.                 foo = NULL;
  215.             } else {
  216.                 index = index->next;
  217.             }
  218.         }
  219.     }
  220.     return(rewind_list(index));
  221. }
  222.  
  223.  
  224. struct user_struct * setup_linked_list(int pwdump, FILE *pwlist, FILE *outlist){
  225.  
  226.     struct user_struct *head, *index;
  227.  
  228.     head = init_linked_list();
  229.  
  230.     build_linked_list(pwdump, head, pwlist);
  231.  
  232.     /* weed out the disabled accounts - only do this for pwdump built
  233.        lists and not for sniffer logs. There shouldn't be any accounts
  234.        that need to be weeded out in the sniffer logs. 
  235.  
  236.            XXX Should
  237.        go through and check if it was a plaintext response here or can
  238.        we figure that people will be bright enough to notice that 
  239.        on their own when they build the sniffer log??? */
  240.  
  241.     if (pwdump){
  242.       index = head;
  243.  
  244.       head = filter_disabled(index, outlist);
  245.  
  246.       index = head;
  247.  
  248.       head = filter_nopasswd(index, outlist);
  249.     }
  250.  
  251.     return(head);
  252. }
  253.  
  254. void nt_ify_list(struct user_struct *head){
  255.   struct user_struct *index;
  256.  
  257.   index = head;
  258.   while (index){
  259.     if (index->lmdone == 1)
  260.       crackntdialect(index, index->lmpasswd, 1);
  261.     index = index->next;
  262.   }
  263. }
  264.  
  265. void print_hits(struct user_struct *head, FILE *outlist){
  266.     struct user_struct *index;
  267.  
  268.     index = head;
  269.     while (index){
  270.         if (index->lmdone == 1)
  271.             printuser(index, outlist);
  272.         index = index->next;
  273.     }
  274. }
  275.  
  276. struct user_struct * prune_list(struct user_struct *head){
  277.     struct user_struct *foo, *tmp, *hold;
  278.  
  279.     foo = tmp = head;
  280.     
  281.     if (head == NULL)
  282.         return(NULL);
  283.  
  284.     /* find the first node that isn't done */
  285.     while (foo->lmdone != 0){
  286.         tmp = foo->next;
  287.         if (tmp == NULL)
  288.             break; /* they are all done */
  289.         foo = tmp;
  290.     }
  291.     
  292.     if (!tmp){ /* they are all done - zorch the list */
  293.         free_struct_list(head);
  294.         return(NULL);
  295.     }
  296.  
  297.     foo = head; /* set index to point to the head */
  298.  
  299.     while (foo != tmp){ /* while index isn't our first none done
  300.                              member... */
  301.         hold = foo->next;
  302.         remove_from_list(foo);
  303.         foo = hold;
  304.     }
  305.  
  306.     head = tmp; /* set our new head to point to the first none done
  307.                    member */
  308.  
  309.     while (tmp){
  310.         if (tmp->lmdone == 1){
  311.             hold = tmp->next;
  312.             remove_from_list(tmp);
  313.             tmp = hold;
  314.         } else {
  315.             tmp = tmp->next;
  316.         }
  317.     }
  318.  
  319.     return(head);
  320. }
  321.         
  322. void swap_structs(struct user_struct *a, struct user_struct *b){
  323.   struct user_struct hold;
  324.  
  325.   /* copy a to hold */
  326.  
  327.   memcpy(&hold, a, sizeof(hold));
  328.  
  329.   /* copy b to a */
  330.  
  331.   memcpy(a, b, sizeof(hold));
  332.  
  333.   /* copy hold to b */
  334.  
  335.   memcpy(&hold, b, sizeof(hold));
  336.  
  337. }
  338.